/**
 * 工程名: 	MyExplorer
 * 文件名: 	ManageFile.java
 * 创建人:  	guo.tianxiang
 * 创建时间: 	2014-2-24 下午9:18:11
 * 版权所有：	Copyright (c) 2014 苏州科大恒星信息技术有限公司  
 * 文件描述: 对文件进行增删改移
 * -----------------------------变更记录 ----------------------------- 
 * 日期        		变更人      		版本号  		变更描述  
 * ------------------------------------------------------------------  
 * 2014-2-24     guo.tianxiang   	1.0       	first created  
 */
package com.tianxiang.service;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.text.ParseException;

import com.tianxiang.dao.MyFileDao;
import com.tianxiang.dao.UserDao;
import com.tianxiang.model.MyFile;
import com.tianxiang.model.Owner;
import com.tianxiang.model.User;
import com.tianxiang.utils.CheckFileSha1;
import com.tianxiang.utils.Tools;

/**
 * 对文件进行增删改移
 * 
 * @since MyExplorer 应用程序版本号
 * @version 1.0 2014-2-24
 * @author guo.tianxiang
 */
public class ManageFileService {
	/**
	 * 
	 * 新建文件或文件夹
	 * 
	 * @param fileName要新建文件的文件名
	 * @param isFolder
	 *            新建的是文件夹还是文件，true表示新建文件夹
	 * @throws IOException
	 * @return成功新建返回true,否则返回false
	 */
	public boolean newFile(String fileName, boolean isFolder)
			throws IOException {
		File file = new File(fileName);
		if (file.exists()) {
			System.out.println("文件" + file + "已存在！");
			return false;
		} else {
			if (isFolder) {
				file.mkdirs();
			} else
				file.createNewFile();
			return true;
		}
	}

	/**
	 * 递归删除文件夹或文件夹
	 * 
	 * @param fileName
	 *            要删除的文件名或是文件夹名
	 * @return
	 */
	public boolean delete(int userId,String fileName) {
		UserDao dao=new UserDao();
		File file = new File(fileName);
		User user=dao.findUserById(userId);
		System.out.println("未刪除前已使用的空間："+user.getUsedspace());
		float size=0;
		boolean result=false;
		if (file.isFile()) {
			size=file.length();					//获取要删除文件大小
			System.out.println("删除的文件大小="+size);
			result=file.delete();
		} else if (file.isDirectory()) {
			size=getFolderSize(file);		//获取要删除文件夹的大小
			System.out.println("删除文件夹大小="+size);
			result=delFolder(fileName);
		}
			if (result) {		//删除成功将数据写回数据库
				System.out.println("删除成功！");
				size=user.getUsedspace()-size;
				user.setUsedspace(size);
				dao.update(user);
			}
		return result;
	}
	/**
	 * 递归删除文件夹或文件夹
	 * 
	 * @param fileName
	 *            要删除的文件名或是文件夹名
	 * @return
	 */
	public boolean delPermanent(String username,String fileName) {
		boolean flag;
		MyFileDao myFileDao = new MyFileDao();
		Owner o=myFileDao.findOwnerFile(username, fileName);
		int fId=o.getFileId();
		MyFile mf = myFileDao.findFileById(fId);
		int userCount=mf.getCount();
		mf.setCount(userCount-=1);
		System.out.println("userCount:"+userCount);
		if(userCount==0){
			File file = new File(mf.getPath());
			if(file.delete()){
				myFileDao.delFile(mf.getFid());
				flag=true;
			}else{
				flag=false;
			}
		}
		if(flag=true&&myFileDao.deOwner(o.getId())){
			flag=true;
		}else{
			flag=false;
		}
		return flag;
	}

	/**
	 * 递归删除文件夹或文件夹
	 * 
	 * @param fileName 要删除的文件名或是文件夹名
	 * @return
	 */
	public boolean delete(String fileName) {
		File file = new File(fileName);
		if (file.isFile()) {
			return file.delete();
		} else if (file.isDirectory()) {
			delFolder(fileName);
			return true;
		}
		return false;
	}
	
	/**
	 * 删除指定文件夹内全部内容
	 * 
	 * @param folderName要删除的文件夹
	 */
	
	private boolean delFolder(String path){ 
		File file = new File(path);
		   if(file.exists()){                    //判断文件是否存在
		    if(file.isFile()){                    //判断是否是文件
		     file.delete();                       //delete()方法 你应该知道 是删除的意思;
		    }else if(file.isDirectory()){              //否则如果它是一个目录
		     File files[] = file.listFiles();               //声明目录下所有的文件 files[];
		     for(int i=0;i<files.length;i++){            //遍历目录下所有的文件
		      this.delFolder(files[i].getAbsolutePath());             //把每个文件 用这个方法进行迭代
		     } 
		    } 
		    file.delete(); 
		    return true;
		   }else{ 
		    System.out.println("所删除的文件不存在！"+'\n');
		    return false;
		   } 
		} 

//	private boolean delFolder(String folderName) {
//		File folder = new File(folderName);
//		// 删除文件夹内全部
//		for (File tempFile : folder.listFiles()) {
//			if (tempFile.isDirectory()) {
//				if (!delFolder(tempFile.getAbsolutePath()))
//					return false;
//				// System.out.println("delete folder "+tempFile.getAbsolutePath()+"……");
//				if (!tempFile.delete())// 删除内部文件夹
//					return false;
//			} else {
//				// System.out.println("delete file "+tempFile
//				// .getAbsolutePath()+"……");
//				if (!tempFile.delete())// 删除文件
//					return false;
//			}
//		}
//		// 删除最后空文件夹
//		if (!folder.delete())
//			return false;
//		return true;
//	}

	/**
	 * 不管是源是文件还是文件夹，都可以进行拷贝，本方法忽略拷贝源的类型
	 * @param src拷贝源，文件或是文件夹
	 * @param dstPath目的文件夹
	 * @return
	 */
	public boolean copy(String username,String fileName, String desName,int id) {
		MyFileDao myFileDao = new MyFileDao();
		Owner o=myFileDao.findOwnerFile(username, fileName);
		Owner owner=new Owner();
		if(o!=null){
			owner.setUsername(username);
			owner.setOfileName(fileName);
			owner.setOuserPath(desName);
			owner.setLastModify(o.getLastModify());
			owner.setFileId(o.getFileId());
		}
		myFileDao.saveOwner(owner);
		
		MyFile myFile=myFileDao.findFileById(o.getFileId());
		float size=Float.parseFloat(myFile.getFileSize());
		
		UserDao dao=new UserDao();
		User user=(User) dao.findUserById(id);
		size=user.getUsedspace()+size;
		user.setUsedspace(size);
		dao.update(user);
		
//		File srcFile = new File(srcName);
//		float size=0;
//	
//		if (srcFile.isFile()) {
//			size=srcFile.length();
//			size=user.getUsedspace()+size;
//			user.setUsedspace(size);
//			dao.update(user);
//			return copyFile(src, dstPath);
//		}
//		if (srcFile.isDirectory()) {
//			size=getFolderSize(srcFile);
//			size=user.getUsedspace()+size;
//			user.setUsedspace(size);
//			dao.update(user);
//			// 拷贝文件夹时要在目的文件夹里新建一个相同的文件夹
//			desName = desName + "\\" + srcFile.getName();
//			return copyFolder(srcName, desName);
//		}
		return true;

	}
	/**
	 * 改方法为删除做准备，特点是不增加已经使用的空间;
	 * @param src拷贝源，文件或是文件夹
	 * @param dstPath目的文件夹
	 * @return
	 */
	public boolean deleteCopy(String src, String dstPath) {
		System.out.println("把"+src+"拷贝到"+dstPath);
		File srcFile = new File(src);
	
		if (srcFile.isFile()) {
			return copyFile(src, dstPath);
		}
		if (srcFile.isDirectory()) {
			// 拷贝文件夹时要在目的文件夹里新建一个相同的文件夹
			dstPath = dstPath + "\\" + srcFile.getName();
			return copyFolder(src, dstPath);
		}
		return true;

	}

	/**
	 * 修改文本类型的文件
	 * 
	 * @param fileName要修改的文件名
	 * @param fileContent修改后的文件内容
	 * @return成功修改返回true,否则返回false
	 */
	public boolean modityFile(String fileName, String fileContent) {
		File file = new File(fileName);
		String temp;
		StringReader stringReader = null;
		FileWriter fileWriter = null;
		BufferedWriter bufferedWriter = null;
		BufferedReader bufferedReader = null;
		try {
			// 实例化IO流
			stringReader = new StringReader(fileContent);
			fileWriter = new FileWriter(file);
			bufferedReader = new BufferedReader(stringReader);
			bufferedWriter = new BufferedWriter(fileWriter);
			while ((temp = bufferedReader.readLine()) != null) {
				bufferedWriter.write(temp);
				bufferedWriter.write('\n'); // 写入换行符
			}
		} catch (IOException e) {

			e.printStackTrace();
		} finally { // 关闭流
			try {
				if (bufferedReader != null) {
					bufferedReader.close();
				}
				if (bufferedWriter != null) {
					bufferedWriter.flush();
					bufferedWriter.close();
				}
				if (fileWriter != null) {
					fileWriter.close();
				}
			} catch (IOException e) {
				System.out.println("流关闭异常！");
				e.printStackTrace();
			}
			if (stringReader != null) {
				stringReader.close();
			}
		}

		return false;

	}

	/**
	 * 拷贝二进制文件到流，为了提高效率Buffer一下是必须的
	 * 
	 * @param srcName 绝对路径下的源文件名
	 * @param dstName 绝对路径下的目的文件夹
	 */
	private void copyContent(String srcName, String dstName) {
		File srcFile= new File(srcName);
		File dstFile=null;
		if(containFile(dstName,srcFile.getName())){
			System.out.println("目标文件夹下已包含目标文件……");
		dstFile=new File(dstName,Tools.getDateFileName(srcFile.getName()));
		}else {
			dstFile=new File(dstName,srcFile.getName());
		}
		try {
			PrintStream out = new PrintStream(new BufferedOutputStream(
					new FileOutputStream(dstFile)));
			BufferedInputStream fis = new BufferedInputStream(
					new FileInputStream(srcFile));
			for (int c; (c = fis.read()) != -1;)
				out.write(c);
			fis.close();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
/**
 * 检查指定文件夹中是否包含给定文件
 * @param dstName 目标文件夹名
 * @param srcName 所要检测的文件名
 * @return
 */
	private boolean containFile(String dstName, String srcName) {
		File []files=new File(dstName).listFiles();
		for (File file : files) {
			if (file.isFile()&&file.getName().equals(srcName)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 
	 * 拷贝srcFile到dstPath目录下，如果该目录不存在则会自动创建
	 * 
	 * @param srcName源文件名
	 * @param dstrName目标文件夹
	 * @return
	 */
	// TODO如果拷贝的是文件夹呢
	private boolean copyFile(String srcName, String dstName) {
		File folderFile = new File(dstName);
		if (!(folderFile.exists()) || !folderFile.isDirectory()) {
			System.out.println("make folder " + folderFile.getAbsolutePath());
			folderFile.mkdirs();
		}
		// TODO 源文件已存在
		copyContent(srcName, dstName);
		return true;
	}

	/**
	 * 文件夹拷贝（递归) 拷贝srcFolderPath文件夹下的文件到dstFolderPath目录下， 如果该目录不存在则会自动创建
	 * 
	 * @param srcFolderPath
	 *            被拷贝的文件夹
	 * @param dstFolderPath
	 *            拷贝文件夹的目标路径
	 */
	private boolean copyFolder(String srcFolderPath, String dstFolderPath) {
		System.out.println("old:"+srcFolderPath);
		System.out.println("new:"+dstFolderPath);
		try {
			for (File file : new File(srcFolderPath).listFiles()) {
				if (!file.isDirectory())
					copyFile(file.getAbsolutePath(), dstFolderPath);
				else
					copyFolder(file.getAbsolutePath(), new File(dstFolderPath,
							file.getName()).toString());
			}
		} catch (Exception e) {
			return false;
		}
		return true;
	}
	   /** 
     * 删除文件夹至回收站，或从回收站还原文件夹 
     * @return boolean 
     */ 
   public void copyToFolder(String oldPath, String newPath) { 
       try { 
           (new File(newPath)).mkdirs(); //如果文件夹不存在 则建立新文件夹 
           File a=new File(oldPath); 
           String[] file=a.list(); 
           File temp=null; 
           for (int i = 0; i < file.length; i++) { 
               if(oldPath.endsWith(File.separator)){ 
                   temp=new File(oldPath+file[i]); 
               } 
               else{ 
                   temp=new File(oldPath+File.separator+file[i]); 
               } 
               if(temp.isFile()){ 
                   FileInputStream input = new FileInputStream(temp); 
                   FileOutputStream output = new FileOutputStream(newPath + "/" + 
                           (temp.getName()).toString()); 
                   byte[] b = new byte[1024 * 5]; 
                   int len; 
                   while ( (len = input.read(b)) != -1) { 
                       output.write(b, 0, len); 
                   } 
                   output.flush(); 
                   output.close(); 
                   input.close(); 
               } 
               if(temp.isDirectory()){//如果是子文件夹 
                   copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]); 
               } 
           } 
       } 
       catch (Exception e) { 
           System.out.println("复制整个文件夹内容操作出错"); 
           e.printStackTrace(); 
       } 
   }

	/**
	 * 
	 * 移动文件
	 * 
	 * @param sourceFile要移动的文件或文件夹
	 * @param desFile要移动的目标文件夹
	 * @return成功移动返回true,否则返回false
	 * @exception 找不到文件抛出
	 */
	public boolean move(String username,String srcName, String desName) {
		MyFileDao myFileDao = new MyFileDao();
		Owner o=myFileDao.findOwnerFile(username, srcName);
		if(o!=null){
			o.setOuserPath(desName);
		}
		myFileDao.updateOwner(o);
		return true;
	}
	
	/**
	 * 
	 * 删除文件至回收站
	 * 
	 * @param sourceFile要移动的文件或文件夹
	 * @param desFile要移动的目标文件夹
	 * @throws ParseException 
	 * @return成功移动返回true,否则返回false
	 * @exception 找不到文件抛出
	 */
	public boolean delToRecycal(int userId,String username,String fileName) throws ParseException {
		MyFileDao myFileDao = new MyFileDao();
		Owner o = myFileDao.findOwnerFile(username, fileName);
		o.setIsAlive(1); //1 表示文件已删除;
		o.setDelTime(Tools.getCurrTime());
		o.setLastModify(Tools.getLastModefyTime());
		myFileDao.saveOwner(o);
		
		int fId=o.getFileId();
		MyFile mf = myFileDao.findFileById(fId);
		float size=Float.parseFloat(mf.getFileSize());
		UserDao userDao=new UserDao();
		User u = userDao.findUserById(userId);
		float usedspace=u.getUsedspace();
		usedspace-=size;
		u.setUsedspace(usedspace);
		userDao.save(u);
//		File file = new File(srcName);
//		
//		if (!file.exists()) {
//			return false;
//		}
//		// 先拷贝
//		deleteCopy(srcName, desFolderName,userId);
//		// 再删除
//		delete(userId,srcName);
		
		return true;
	}

	/**
	 * 读取文本文件内容 只能解决系统默认编码为gbk的文件，编码为utf-8的读取会乱码
	 * @param fileName
	 *            要读取的文件名
	 * @return 返回读取的文本
	 */
	public String readFile(String fileName) {
		StringBuffer contentString = new StringBuffer();
		InputStreamReader isr = null;
		BufferedReader read = null;
		try {
			isr = new InputStreamReader(new FileInputStream(fileName), "gbk");
			read = new BufferedReader(isr);
			String s = null;
			while ((s = read.readLine()) != null) {
				contentString.append(s);
				contentString.append('\n');
			}
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (read != null) {
				try {
					read.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (isr != null) {
				try {
					isr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return contentString.toString();
	}
	public long getFolderSize(File f) // 取得文件夹大小
	{
		long size = 0;
		File flist[] = f.listFiles();
		for (int i = 0; i < flist.length; i++) {
			if (flist[i].isDirectory()) {
				size = size + getFolderSize(flist[i]);
			} else {
				size = size + flist[i].length();
			}
		}
		return size;
	}
	
	public static void main(String[] args) {
		long startTime, endTime;
		float time;
		ManageFileService mf = new ManageFileService();
		System.out.println("Start ……");
		startTime = System.nanoTime();
		// mf.copy("D:\\桌面图标", "d:\\testfolder");
		// mf.delete("d:\\testfolder");
		// mf.move("d:\\test\\doc", "d:\\");
		mf.copyContent("d:\\选题申请表(样表).doc", "D:\\test\\doc");
		// System.out.println(mf.readFile("D:\\rfc\\RFC101-200\\RFC101.txt"));
//		mf.modityFile("d:\\testfile.txt",
//				mf.readFile("D:\\WorkSpaces\\Workspace_JavaEE\\test\\天龙八部.txt"));
		endTime = System.nanoTime();
		System.out.println("Complete !");
		time = (float) ((endTime - startTime) / 1000000000.0);
		System.out.println("共计用时" + time + "秒");
	}

	public boolean reverse(int userId,String userName,String fileName) {
		
		
		MyFileDao myFileDao = new MyFileDao();
		Owner owner = myFileDao.findOwnerFile(userName, fileName);
		int isAlive=owner.getIsAlive();
		if(isAlive==1){
			owner.setIsAlive(0);
		}
		myFileDao.saveOwner(owner);
		int fId=owner.getFileId();
		MyFile mf = myFileDao.findFileById(fId);
		Float size=Float.parseFloat(mf.getFileSize());
		UserDao userDao = new UserDao();
		User user = userDao.findUserById(userId);
		float usedSpace=user.getUsedspace();
		usedSpace+=size;
		user.setUsedspace(usedSpace);
		if(userDao.save(user)){
			return true;
		}
			return false;
	}
	public int fileAlreadyExist(File f){
		MyFileDao fileDao=new MyFileDao();
		String code=CheckFileSha1.getFileSha1(f);
		MyFile myFile=fileDao.findByFileCode(code);
		if(myFile!=null){
			System.out.println("myFile-->"+myFile);
			return myFile.getFid();
		}
		return -1;
	}
	public MyFile getAlreadyFileByCode(String code){
		MyFileDao fileDao=new MyFileDao();
		MyFile myFile=fileDao.findByFileCode(code);
		if(myFile!=null){
			return myFile;
		}
		return null;
	}
	public MyFile getAlreadyFile(File f){
		MyFileDao fileDao=new MyFileDao();
		String code=CheckFileSha1.getFileSha1(f);
		MyFile myFile=fileDao.findByFileCode(code);
		if(myFile!=null){
			return myFile;
		}else{
			return null;
		}
	}
	public MyFile getFile(String username,String fileName){
		MyFileDao fileDao=new MyFileDao();
		Owner o = fileDao.findOwnerFile(username, fileName);
		int fId=o.getFileId();
		MyFile myFile=fileDao.findFileById(fId);
		if(myFile!=null){
			return myFile;
		}else{
			return null;
		}
	}
	public boolean saveFile(File f,String fileName,String fileType,String path,String code){
		//String code=CheckFileSha1.getFileSha1(f);
		System.out.println("code-->"+code);
		MyFileDao fileDao=new MyFileDao();
		System.out.println("fId-->"+this.fileAlreadyExist(f));
		if(this.fileAlreadyExist(f)==-1){ //文件不存在，保存一份文件信息
			fileDao.save(f,fileName,fileType,code,path);
			return true;
		}
		return false;
	}
	public boolean saveOwner(String username,String ofileName,String userPath,String currentTime,int fId){
		MyFileDao fileDao=new MyFileDao();
		Owner owner=new Owner(); 
		owner.setFileId(fId);
		owner.setLastModify(currentTime);
		owner.setOfileName(ofileName);
		owner.setOuserPath(userPath);
		owner.setUsername(username);
		fileDao.saveOwner(owner);
		return true;
	}

	public boolean delFolder(String fileName, String folderPath, String recycalPath) {
		copyToFolder(folderPath, recycalPath+"\\"+fileName);
		System.out.println("删除文件夹成功："+this.delFolder(folderPath));
		return true;
	}

	public boolean reverseFolder(int userId,String fileName, String userPath, String path) {
		copyToFolder(path, userPath+"\\"+fileName);
		this.delFolder(path);
		return true;
	}

	public boolean delFolderPermanent(String userPath) {
		this.delFolder(userPath);
		return true;
	}
}
